The first computers were very hard to use and did not resemble the relatively easy to use personal computer (“PCs”) of today. Over time, however, computer systems have become much more “user-friendly” and easy to use, based on a continual rise in the level of abstraction. The following are examples of the evolution of extractions that has taken place.
(1) 1GL->2GL->3GL->4GL Programming Languages
Programming languages evolved through several “generations.” At present, there are at least four. The fourth generation programming languages, 4GLs, are various languages, some of which are proprietary. These four generation programming languages include “PowerBuilder” by Sybase, Inc., “RPG” and “PL/1” by IBM, and “ABAP” by SAP, Inc. SQL (Structured-Query Language) is also regarded by many as a 4GL.
(2) Sequential files->Indexed files->Hierarchic Databases->SQL Databases
Over the years, more and more of the details of storing and managing data have been taken over by the computer system. The evolution from sequential filing, which required a great deal of time for the user to find desired information, to SQL database, which provides a rapid method of data retrieval, has provided the mechanism for the movement from the system user directly accessing stored data to the computing system being the actual tool to perform the retrieval with only high-level directions from the system user. Therefore, today it's the system, not the user, that's responsible for locating and retrieving data.
The 4GL programming languages that are mentioned above are meant to be examples of current generation languages but is not all inclusive. However, these 4GL programming languages may be combined through the use of data management systems to develop computer-based applications. In this context, an application, may be the implementation of some type of business function such as “entering an order for a customer,” or “deleting an order.” In general, applications of this type include four parts or components:                1. Presentation Aspects        2. Database Aspects        3. Specific Business Function Aspects        4. Aspects Specific to Making the Application Available to End Users        
The “Presentation Aspects” are used to define the end-user interface. For example, they include (i) accepting filled-out forms from the end user, (ii) displaying error messages, or (iii) producing printed output. The “Database Aspects” are generally associated with retrieving and updating database information in response to end-user requests and end-user entries on forms. The “Specific Business Function Aspects,” on the other hand, delineate the actual process steps to be performed to implement the business function. Lastly, the “Aspects Specific to Making the Application Available to End Users” are responsible for providing the “Presentation Aspects” to end users regardless of end user location.
Another way to view applications is as a set of logical tiers. A “Presentation Tier” is responsible for the “Presentation Aspects.” A “Database Tier” is responsible for carrying out the “Database Aspects.” An “Application Tier” is responsible for implementing the “Specific Business Function Aspects.” Finally, a “Serving Tier” is responsible for making the “Presentation Tier” available to all users accessing the application.
Most of the applications today are written using the four tiers just mentioned. However, there may be stark differences from application to application as to how these tiers are implemented and how they interact with each other. For example, in a client/server application, a PC communicates with a server computer. Typically, the PC will be running the presentation tier, the servicing tier, and part of the application tier and the serving tier. At the same time, the server computer typically will be running the database tier and another part of the application tier. Client/server applications are sometimes referred to “thick client” applications due to the size of the code that has to be installed on the PC. This and other issues contribute to “thick client” applications being hard to maintain.
On the other hand, typical mainframe, midrange, and iSeries (AS/400) by IBM applications differ from client/server applications. The main difference is that instead of splitting the tier functions between two computers, all four tiers are running on the same computer or server. When this is the situation, the serving tier manages the flow of information between the server and the terminals used by end users to access and uses the application. In the case, of the iSeries, the end user terminals are 5250 terminals or 5250 emulated terminals running on a PC. In most cases, the data that is transmitted between the server and the end user terminal is based on proprietary APIs.
The evolution of the application approach has resulted in what is now referred to as a “web application.” There are two main characteristics that distinguish web applications from other applications. The first is that the serving tier is a combination of one or more web servers. Examples of these are the Microsoft “Internet Information Server”, IBM “HTTP Server”, Sun Microsystems “Apache.” The second is that the serving tier sends and receives information (information in this context includes application data and any other data used to present that application data to end users) from web browsers such as Netscape “Navigator” or Microsoft “Internet Explorer.” This information includes application data and the data used to present application information to the end users.
As computers became more powerful, they served the role as web browsers and web servers. This increased power also meant they had the capability to handle more complicated tasks. Thus, companies developed more sophisticated web applications that made use of this power. In web application systems where these computers were used, certain activities are defined as “web server side” and “web browser” activities. The following addresses the distinction between these two activity types:
Web Server Side
The development and popularity of web server-side Java applications following the introduction and use of Java programming. The Java language was originally intended for use in small embedded devices. It was first provided as a language for developing elaborate client-side web content in the form of applets. However, as time progressed, Java was being used as a language better suited for server-side development.
Java servlets are an important component of server-side Java development. A servlet is a small, pluggable extension to a server that enhances the server's functionality. Servlets allow developers to extend and customize any Java-enabled server with great degrees of portability, flexibility, and ease of use.
When Java servlets are used to create dynamic content for a web page or extend the functionality of a web server, this, in effect, is creating a web application. A web page in or of itself displays static content that the user can navigate. A web application provides for more substantive interaction with the web page than just this. A web application can be as simple as a keyword search on a document or as complex as an order entry system. Web applications are being deployed for use over the Internet and on corporate intranets and extranets. These web applications have the potential to increase productivity and change the way that companies, large and small do business.
Servlets, such as the Java servlets discussed above, are but one method for developing web applications. The following are other methods by which web applications may be developed:                1. CGI (Common Gateway Interface)        2. Fast CGI        3. Server extension APIs        4. ASP (Active Server Pages)        5. Server-side JavaScript        
With regard to server extension APIs, there are several companies that have created proprietary server extension APIs for web servers. For example, Netscape provides an internal API that is named “NSAPI” and Microsoft provides one named “ISAPI.” These APIs will permit the developer to write server extensions to enhance or change the basic functionality of the server. This in turn will allow the server to handle tasks that were once relegated to external CGI programs.
Web Browsers
Web browsers also have evolved. The first web browsers were only capable of displaying static content. This relegated the end user to navigate the static information by following hyperlinks. These pages were sent from the web server to the web browser via the Hyper-Text Transmission Protocol (“HTTP”) and written using the Hyper-Text Mark-up Language (HTML). More specifically, the first web browsers were only able to interpret HTML pages and display them. HTML was only capable of producing static content which is insufficient to create web applications. It became understood that for HTML and the web browser to be able to create web applications, they had to be enhanced.
The enhancements that made web application possible in many cases were on the systems client-side. Client-side in this context is the portion of system where the end user interacts with it to communicate with the server. Some client-side technologies that have facilitated the development of web applications are the following:                1. Dynamic Hyper-Text Mark-up Language (“DHTML”)        2. Java Applets        3. ActiveX controls        4. Extensible Mark-up Language (“XML”)        
DHTML is an extension to HTML. It will allow the developer to create dynamic web pages or pages that can be changed based on end user input. Java Applets are Java programs that run in the context of a Java-enabled web browser. ActiveX controls are programs written in C, C++, VB, Java, or other language that is run in the context of an ActiveX enabled web browser. XML is considered the universal exchange format between the web browser and server. As such, it is widely used. Many web browsers have had their capabilities extended to support XML.
As stated, typically, the web browser and the web server communicate using the Hyper-Text Transmission Protocol (“HTTP”). HTTP is a simple, stateless transmission protocol. A system client, such as a web browser, makes a request which is transmitted using HTTP and the web server responds using HTTP. When the client sends the request, the first thing that is specified is an HTTP command, called a “Method.” The “Method” tells the server the type of action it wants performed. This first line of the request also specifies the address of a document (URL) and the version of the HTTP protocol it is using. An example of this follows:                GET/infinium.html HTTP/1.0According to this example, the request uses the GET method to ask for the document named “infinium.html” using HTTP Version 1.0. After sending the request, the client can send optional information. After the client sends the request, the server processes it and sends back the response.        
There is a need for a system and method that will effectively and efficiently handle web applications.